// 获取TX短信转发脚本 - Surge版 v20250620233245
// 完全适配 Surge 官方API，支持自动和手动两种运行模式
// 官方文档: https://manual.nssurge.com/scripting/

const SCRIPT_VERSION = '20250620233245';
const SCRIPT_DATE = '2025-06-20';
const PLATFORM = 'Surge';

console.log(`📱 ${PLATFORM}短信转发脚本启动 v${SCRIPT_VERSION} (${SCRIPT_DATE})`);

// 检测脚本运行模式
const isHttpRequest = typeof $request !== 'undefined' && $request.url;
const isGenericCall = typeof $argument !== 'undefined' || !isHttpRequest;

console.log(`🔧 运行模式: ${isHttpRequest ? 'HTTP拦截模式' : 'Generic手动模式'}`);

// Surge 参数获取 - 支持多种获取方式
// 优先级：$argument > URL参数 > 默认值
const params = {
    notify: getParam('notify', '辰星短信'),
    tokenetc: getParam('tokenetc', 'fysms.deno.dev'),
    allsms: getBoolParam('allsms', true),
    regexstr: getParam('regexstr', '码|碼|code|\\d{4,}'),
    sender_filter: getParam('sender_filter', ''),
    debug_mode: getBoolParam('debug_mode', false),
    retry_count: getIntParam('retry_count', 1),
    timeout_seconds: getIntParam('timeout_seconds', 10)
};

// 参数获取辅助函数
function getParam(name, defaultValue) {
    try {
        // 优先从 $argument 获取（Generic模式）
        if (typeof $argument !== 'undefined' && $argument) {
            if (typeof $argument === 'object' && $argument[name] !== undefined) {
                return $argument[name];
            }
            // 如果$argument是字符串，解析为URL参数格式
            if (typeof $argument === 'string') {
                const params = new URLSearchParams($argument);
                const value = params.get(name);
                if (value !== null) {
                    return value;
                }
            }
        }
        
        // 从URL参数获取（HTTP拦截模式）
        if (typeof $request !== 'undefined' && $request.url) {
            const url = new URL($request.url);
            const paramValue = url.searchParams.get(name);
            if (paramValue !== null) {
                return paramValue;
            }
        }
    } catch (error) {
        console.log(`⚠️ 获取参数 ${name} 时出错:`, error);
    }
    return defaultValue;
}

function getBoolParam(name, defaultValue) {
    const value = getParam(name, defaultValue.toString());
    if (typeof value === 'boolean') return value;
    if (typeof value === 'string') {
        return value.toLowerCase() === 'true' || value === '1';
    }
    return defaultValue;
}

function getIntParam(name, defaultValue) {
    const value = getParam(name, defaultValue.toString());
    const intValue = parseInt(value);
    return isNaN(intValue) ? defaultValue : intValue;
}

// 通知方式映射
const notifyMap = {
    '钉钉': '0',
    'Server酱': '1', 
    '辰星短信': '2'
};

params.notify = notifyMap[params.notify] || '2';

console.log('🔧 Surge参数配置:');
Object.keys(params).forEach(key => {
    console.log(`🔧 - ${key}: ${JSON.stringify(params[key])}`);
});

// 参数验证
if (!params.tokenetc || params.tokenetc.trim() === '') {
    console.log('❌ tokenetc 参数为空');
    $notification.post('Surge短信转发', '配置错误', 'tokenetc参数为空，请在脚本界面配置参数');
    $done({});
    throw new Error('tokenetc parameter is required');
}

if (!['0', '1', '2'].includes(params.notify)) {
    console.log('❌ 通知方式无效:', params.notify);
    $notification.post('Surge短信转发', '配置错误', `无效的通知方式: ${params.notify}`);
    $done({});
    throw new Error('Invalid notify parameter');
}

// 发信人过滤检查
function checkSenderFilter(sender) {
    if (!params.sender_filter || params.sender_filter.trim() === '') {
        console.log('🔍 发信人过滤: 未设置过滤条件，允许所有发信人');
        return true;
    }
    
    const allowedSenders = params.sender_filter.split(',').map(s => s.trim()).filter(s => s !== '');
    console.log(`🔍 检查发信人: "${sender}" 是否在允许列表 [${allowedSenders.join(', ')}] 中`);
    
    const isAllowed = allowedSenders.some(allowed => {
        return sender === allowed || sender.includes(allowed) || allowed.includes(sender);
    });
    
    console.log(`🔍 过滤结果: ${isAllowed ? '✅ 允许转发' : '❌ 拒绝转发'}`);
    
    if (params.debug_mode) {
        $notification.post('发信人过滤', 
            isAllowed ? '✅ 允许转发' : '❌ 拒绝转发', 
            `发信人: ${sender}\n允许列表: ${allowedSenders.join(', ')}`);
    }
    
    return isAllowed;
}

// 获取短信数据
function getSmsData() {
    console.log('📱 开始获取短信数据...');
    
    // 方法1: 从 $request.body 获取真实短信数据（HTTP拦截模式）
    if (isHttpRequest && typeof $request !== 'undefined' && $request.body) {
        console.log('📱 从 $request.body 获取真实短信数据');
        try {
            const requestData = JSON.parse($request.body);
            
            if (params.debug_mode) {
                console.log('📦 原始请求数据:', JSON.stringify(requestData, null, 2));
                $notification.post('Surge调试', '获取到真实短信', '数据来源: $request.body');
            }
            
            // 支持多种数据格式
            if (requestData.query && requestData.query.message) {
                return {
                    sender: requestData.query.sender || '未知发送方',
                    message: requestData.query.message.text || requestData.query.message
                };
            } else if (requestData.sender && requestData.message) {
                return {
                    sender: requestData.sender,
                    message: requestData.message
                };
            }
        } catch (error) {
            console.log('❌ 解析 $request.body 失败:', error);
            if (params.debug_mode) {
                $notification.post('Surge解析错误', '请求体解析失败', error.toString());
            }
        }
    }
    
    // 方法2: Generic模式使用测试数据
    const mode = isGenericCall ? 'Generic手动测试模式' : '调试模式';
    console.log(`⚠️ 使用测试数据 (${mode})`);
    
    if (isGenericCall) {
        $notification.post('Surge配置测试', '使用模拟短信测试', '点击此脚本进行参数配置和功能测试');
    } else if (params.debug_mode) {
        $notification.post('Surge调试模式', '使用测试数据', '无真实短信时使用模拟数据测试');
    }
    
    return {
        sender: '10086',
        message: `【Surge测试】您的验证码是654321，请在5分钟内输入。[${mode}: ` + new Date().toLocaleString('zh-CN', {timeZone: 'Asia/Shanghai'}) + ']'
    };
}

// 发送到辰星短信
function sendToChenXing(server, smsData) {
    console.log('🔧 辰星短信通知 - Surge版');
    console.log(`🔧 目标服务器: "${server}"`);
    
    // 构建完整URL
    let url;
    if (server.startsWith('http://') || server.startsWith('https://')) {
        url = server.endsWith('/sms') ? server : `${server}/sms`;
    } else {
        url = `https://${server}/sms`;
    }
    
    console.log(`📍 请求URL: "${url}"`);
    
    // 提取验证码
    const codeMatch = smsData.message.match(/验证码[：:]?(\d{4,8})/);
    const verificationCode = codeMatch ? codeMatch[1] : '';
    console.log(`🔢 提取验证码: "${verificationCode}"`);
    
    if (params.debug_mode && verificationCode) {
        $notification.post('验证码提取', `成功提取: ${verificationCode}`, `来源: ${smsData.sender}`);
    }
    
    // 构建请求数据
    const requestData = {
        sender: smsData.sender,
        message: smsData.message,
        code: verificationCode,
        timestamp: Date.now(),
        source: "surge_sms",
        version: SCRIPT_VERSION,
        platform: PLATFORM
    };
    
    const requestBody = JSON.stringify(requestData);
    console.log('📦 Surge请求数据:', requestBody);
    
    // 发送HTTP请求
    sendSurgeHttpRequest(url, requestBody);
}

// 发送到钉钉
function sendToDingTalk(config, smsData) {
    console.log('📤 钉钉通知 - Surge版');
    const configParts = config.split('.');
    if (configParts.length < 2) {
        console.log('❌ 钉钉配置格式错误');
        $notification.post('Surge配置错误', '钉钉格式错误', '格式: 关键词.Token');
        $done({});
        return;
    }
    
    const keyword = configParts[0].trim();
    const token = configParts[1].trim();
    const url = `https://oapi.dingtalk.com/robot/send?access_token=${token}`;
    
    const requestData = {
        msgtype: "text",
        text: {
            content: `${keyword}\n[Surge转发]\n发送号码: ${smsData.sender}\n短信内容: ${smsData.message}`
        }
    };
    
    sendSurgeHttpRequest(url, JSON.stringify(requestData));
}

// 发送到Server酱
function sendToServerChan(sendkey, smsData) {
    console.log('📤 Server酱通知 - Surge版');
    
    let url;
    if (sendkey.startsWith('sctp')) {
        const match = sendkey.match(/^sctp(\d+)t/);
        if (match) {
            url = `https://${match[1]}.push.ft07.com/send/${sendkey}.send`;
        } else {
            url = `https://sctapi.ftqq.com/${sendkey}.send`;
        }
    } else {
        url = `https://sctapi.ftqq.com/${sendkey}.send`;
    }
    
    const requestData = {
        title: "Surge短信转发",
        desp: `**发送号码:** ${smsData.sender}\n\n**短信内容:** ${smsData.message}\n\n**转发时间:** ${new Date().toLocaleString('zh-CN', {timeZone: 'Asia/Shanghai'})}`
    };
    
    sendSurgeHttpRequest(url, JSON.stringify(requestData));
}

// Surge HTTP请求发送（使用官方API）
function sendSurgeHttpRequest(url, body, currentRetry = 0) {
    console.log(`📡 Surge网络请求 (第${currentRetry + 1}次尝试)`);
    console.log(`📍 URL: ${url}`);
    
    if (params.debug_mode) {
        console.log(`📦 Body: ${body}`);
        $notification.post('Surge网络请求', `发送中... (${currentRetry + 1}/${params.retry_count})`, 
            `目标: ${url.includes('deno.dev') ? 'Deno服务' : '第三方服务'}`);
    }
    
    // Surge官方API格式
    const requestOptions = {
        url: url,
        headers: {
            'Content-Type': 'application/json',
            'User-Agent': `Surge-SMS-Forwarder/${SCRIPT_VERSION}`,
            'X-Script-Version': SCRIPT_VERSION,
            'X-Script-Platform': PLATFORM,
            'X-Script-Date': SCRIPT_DATE
        },
        body: body
    };
    
    if (params.debug_mode) {
        console.log('📋 Surge请求配置:', JSON.stringify(requestOptions, null, 2));
    }
    
    // 使用Surge官方 $httpClient.post API
    $httpClient.post(requestOptions, function(error, response, data) {
        console.log('📡 Surge收到响应');
        
        if (error) {
            console.log('💥 Surge请求错误:', error);
            
            if (params.debug_mode) {
                $notification.post('Surge网络错误', '请求失败', 
                    `错误: ${error}\n重试: ${currentRetry + 1}/${params.retry_count}`);
            }
            
            // 重试逻辑
            if (currentRetry < params.retry_count - 1) {
                console.log(`🔄 准备重试 (${currentRetry + 1}/${params.retry_count - 1})`);
                setTimeout(() => {
                    sendSurgeHttpRequest(url, body, currentRetry + 1);
                }, 2000 * (currentRetry + 1)); // 递增延迟
                return;
            }
            
            $notification.post('Surge网络失败', `重试${params.retry_count}次后仍失败`, error.toString());
            $done({});
        } else {
            const statusCode = response.status || response.statusCode || 200;
            console.log(`✅ Surge请求成功，状态码: ${statusCode}`);
            
            if (params.debug_mode) {
                console.log('📊 Surge响应头:', JSON.stringify(response.headers || {}, null, 2));
                console.log('📊 Surge响应数据:', data);
                $notification.post('Surge网络响应', `状态码: ${statusCode}`, 
                    `响应: ${data ? data.substring(0, 100) + '...' : '无数据'}`);
            }
            
            if (statusCode >= 200 && statusCode < 300) {
                $notification.post('Surge转发成功', `状态码: ${statusCode}`, 
                    `验证码已通过Surge成功发送 ✅`);
            } else {
                console.log(`⚠️ Surge服务器响应异常，状态码: ${statusCode}`);
                
                // 对于服务器错误进行重试
                if (statusCode >= 500 && currentRetry < params.retry_count - 1) {
                    console.log(`🔄 服务器错误重试 (${currentRetry + 1}/${params.retry_count - 1})`);
                    setTimeout(() => {
                        sendSurgeHttpRequest(url, body, currentRetry + 1);
                    }, 3000 * (currentRetry + 1));
                    return;
                }
                
                $notification.post('Surge转发异常', `状态码: ${statusCode}`, 
                    '服务器响应异常，请检查配置');
            }
            
            $done({});
        }
    });
}

// 主处理流程
function main() {
    console.log('🚀 Surge短信转发开始处理');
    
    try {
        // 获取短信数据
        const smsData = getSmsData();
        if (!smsData) {
            console.log('❌ 无法获取短信数据');
            $notification.post('Surge短信转发', '数据错误', '无法获取短信数据');
            $done({});
            return;
        }
        
        console.log(`📨 短信信息: 发送方=${smsData.sender}, 内容=${smsData.message.substring(0, 50)}...`);
        
        // 检查发信人过滤
        if (!checkSenderFilter(smsData.sender)) {
            console.log('❌ 发信人被过滤，跳过转发');
            $done({});
            return;
        }
        
        // 检查内容匹配规则
        if (!params.allsms && !new RegExp(params.regexstr).test(smsData.message)) {
            console.log('❌ 短信内容不匹配规则，跳过转发');
            if (params.debug_mode) {
                $notification.post('Surge规则不匹配', '短信跳过', 
                    `内容: ${smsData.message.substring(0, 20)}...\n规则: ${params.regexstr}`);
            }
            $done({});
            return;
        }
        
        console.log('✅ 短信匹配规则，准备使用Surge转发');
        
        // 根据通知方式转发
        switch (params.notify) {
            case '0':
                console.log('📤 使用钉钉通知 (Surge)');
                sendToDingTalk(params.tokenetc, smsData);
                break;
            case '1':
                console.log('📤 使用Server酱通知 (Surge)');
                sendToServerChan(params.tokenetc, smsData);
                break;
            case '2':
                console.log('📤 使用辰星短信通知 (Surge)');
                sendToChenXing(params.tokenetc, smsData);
                break;
            default:
                console.log('❌ 未知的通知方式:', params.notify);
                $notification.post('Surge配置错误', '未知通知方式', `notify=${params.notify}`);
                $done({});
        }
        
    } catch (error) {
        console.log('💥 Surge脚本执行错误:', error);
        $notification.post('Surge脚本错误', '执行异常', error.toString());
        $done({});
    }
}

// 启动主程序
console.log('🎯 启动Surge短信转发主程序...');
main(); 